import {
  getNum,
  toStringTypeCheck,
  emptyClone,
  formatObj,
  ObjectOnlyPushSet,
} from '../../../../components/aaanewApp/global/global';
import { funcAsync } from '../functionAsync/functionAsync';

const taskStatus = {
  done: 'done',
  wait: 'wait',
  running: 'running',
};

let taskSettleInf = {
  data: [
    'task',
    'stopTask',
    'reTask',
    'runTask',
    'taskInfo',
    'mindTask',
    'mindTaskCall',
  ],
  task: [],
  taskInfo: {
    currentIndex: 0,
    currentPropsObj: {},
    status: taskStatus.wait,
    mindData: [],
  },
  stopTask: stopTask,
  reTask: reTask,
  runTask: runTask,
  mindTask: mindTask,
  //   mindTask 验证符位
  mindTaskCall: true,
};

const data = 'data';
/**
 * 当前 任务 指标 初始为 0 默认 顺序执行任务
 */
const currentIndex = 'currentIndex';

const currentPropsObj = 'currentPropsObj';

/**
 * 实例 的 task 目标
 */
const infactTask = 'task';

const taskInfo = 'taskInfo';

const formated = 'formated';

/**
 * 函数 延迟 运行 信息
 */
const delayRunInf = 'delayRun';

/**
 * 函数 延迟 方式
 */
const delayWay = 'delayWay';

/**
 * 函数 延迟 时间 暂且 单位是 毫秒 --之后 再改
 */
const delayTime = 'delayTime';

/**
 * 解析后的 函数 需求参数
 */
const asyncFuncfuncArg = 'funcArg';

/**
 * 实例 的 函数 runBranch 分支类型
 */
const infactRunBranch = 'runBranch';

/**
 * 实例 的 props 目标
 */
const infactProps = 'props';

// 异步函数
const runAsync = 'asyncFunc';

// 异步运行完成 项
const asyncDone = 'done';

// 最后一个 未 运行的 完成的 异步函数
const lastAsyncFunc = 'lastAsyncFunc';

/**
 * 实例 的 propsVal 目标
 */
const infactPropsVal = 'propsVal';

const regSwitchFuncReturn_o = {
  reReturn: /.*\.return/,
  reObject: /.*\.object/,
  reArray: /.*\.array/,
};

const runBranches = {
  delayRun: 'delayRun',
  asyncRun: 'asyncRun',
  then: 'then',
  next: 'next',
};

const delayways = {
  with: 'with',
  after: 'after',
};

const formatPropTaskFunc = {
  function: function () {
    return this.value;
  },
  //   funcName: function () {
  //     return this.value.name;
  //   },
  describe: [
    undefined,
    function () {
      return this.describe;
    },
  ],
  runBranch: function () {
    return this.delayTime != undefined
      ? runBranches.delayRun
      : this.asyncFunc != undefined
      ? runBranches.asyncRun
      : this.then != undefined
      ? runBranches.then
      : runBranches.next;
  },
  delayRun: [
    undefined,
    function () {
      if (this.delayTime != undefined) {
        return {
          delayTime: getNum(this.delayTime) || getNum(this.delay),
          delayWay: this.delayWay || delayways.with,
        };
      }
    },
  ],
  asyncRun: [
    undefined,
    function () {
      if (this.asyncFunc != undefined) {
        return {
          asyncFunc: 'promise',
        };
      }
    },
  ],
  then: [
    undefined,
    function () {
      if (this.then) {
        const thenN = 'thenFunc';
        let f = lastAsyncFunc;
        if (toStringTypeCheck(this.then, 'object')) {
          f = this.then[thenN] | lastAsyncFunc;
        }
        return {
          then: f,
        };
      }
    },
  ],
};

function stopTask() {
  // 当前域 挂在 函数的
  //   console.log(this);
  this[taskInfo]['status'] = taskStatus.wait;
}

function reTask() {
  //   console.log(this);
  this[taskInfo][currentIndex] = 0;
  rebackProps();
  startTask(this);
}

function runTask() {
  startTask(this);
}

/**
 * 启动 task 运行
 */
function startTask(that) {
  that[taskInfo]['status'] = taskStatus.running;
  FunctionCall(that);
}

/**
 * task 函数运行 Keyfunc
 * -
 * 利用 Function 创建 自定义函数 再实时 调用 task 中的 定义 并且 传入参数 和 调取 添加 新 props 信息
 * @param {this} that this avanda 用户实例
 */
function FunctionCall(that) {
  // 当前函数 如果 不能运行 则 直接 退出 该 函数运行
  if (!taskRunStatusCheck(that)) {
    return;
  }
  //   infactTask;
  /**
   * 当前 task 指针
   */
  let curr_I = that[taskInfo][currentIndex];
  //   console.log(curr_I);

  /**
   * 实时 格式化 task 单个函数对象
   */
  if (!that[infactTask][curr_I][formated]) {
    that[infactTask][curr_I] = formatObj(
      formatPropTaskFunc,
      that[infactTask][curr_I]
    );
  }

  //   console.log(currfunc);

  switch (that[infactTask][curr_I][infactRunBranch]) {
    /**
     * 直接 next 链
     */
    case runBranches.next: {
      //   当前 指针 任务函数
      const currfunc = that[infactTask][curr_I]['function'];
      let asyFun_o = funcAsync(currfunc);

      let createFunc_o = fillFunc(asyFun_o);
      let callArgu = getqueryArgus(asyFun_o.funcArg, that);
      //   ObjectOnlyPushSet(that, createFunc_o.key, undefined, infactProps);
      //   that[infactPropsVal][createFunc_o.key] = createFunc_o.function(
      //     ...callArgu
      //   );
      // 当前 task 任务 执行 序号
      presetPropInf(
        that,
        createFunc_o.key,
        createFunc_o.function.call(that, ...callArgu)
      );
      that[taskInfo][currentIndex]++;
      break;
    }
    case runBranches.delayRun: {
      if (that[infactTask][curr_I][delayRunInf][delayWay] == delayways.with) {
        let asyFun_o = paddingsetTimeout(that[infactTask][curr_I]);
        let createFunc_o = fillFunc(asyFun_o);
        let callArgu = getqueryArgus(asyFun_o.funcArg, that);
        asyncfunc(that, createFunc_o, callArgu);
        that[taskInfo][currentIndex]++;
      } else if (
        that[infactTask][curr_I][delayRunInf][delayWay] == delayways.after
      ) {
        let asyFun_o = paddingsetNth(that[infactTask], curr_I);
        let createFunc_o = fillFunc(asyFun_o);
        let callArgu = getqueryArgus(asyFun_o.funcArg, that);
        asyncfunc(that, createFunc_o, callArgu);
        that[taskInfo][currentIndex]++;
      }
      break;
    }
    case runBranches.asyncRun: {
      //   当前 指针 任务函数
      const currfunc = that[infactTask][curr_I]['function'];
      let asyFun_o = funcAsync(currfunc);

      let createFunc_o = fillFunc(asyFun_o);
      let callArgu = getqueryArgus(asyFun_o.funcArg, that);
      // 当前 task 任务 执行 序号
      asyncfunc(that, createFunc_o, callArgu, runAsync);
      that[taskInfo][currentIndex]++;
      break;
    }
    case runBranches.then: {
      let asyncStatus = getLastAsyncFunc(
        that,
        that[infactTask][curr_I][runBranches.then][runBranches.then]
      );
      //   异步函数 未运行完成 则 进行 Proxy 监听 Done
      if (asyncStatus.runAsync[asyncDone] != asyncDone) {
        that.stopTask();
        let a = new Proxy(asyncStatus.runAsync, { set: doneListen });
        that[runAsync][asyncStatus.funcName] = a;
        return;
      }

      //   当前 指针 任务函数
      const currfunc = that[infactTask][curr_I]['function'];
      //   console.log(that);
      let asyFun_o = funcAsync(currfunc);

      let createFunc_o = fillFunc(asyFun_o);
      let callArgu = getqueryArgus(asyFun_o.funcArg, that);
      // 当前 task 任务 执行 序号
      asyncfunc(that, createFunc_o, callArgu);
      that[taskInfo][currentIndex]++;
      break;
    }
    default:
      break;
  }
  function doneListen(this_o, key, val) {
    this_o[key] = val;
    if (key == asyncDone && val == asyncDone) {
      that.runTask();
    }
    return true;
  }
  /**
   * 串联调用
   */
  FunctionCall(that);
}

/**
 * 判断 当前 task 函数 的 运行状态
 * @param {this} that this avanda 用户实例
 */
function taskRunStatusCheck(that) {
  let returninf = true;

  // 如果 当前 task 状态 是 wait 直接返回 不运行 及 创建函数了
  if (that[taskInfo]['status'] == taskStatus.wait) {
    return false;
  }
  // 如果 当前 task 状态 是 done  立即 完结任务 -- 使用于 mindTask 的 rebackTask 特殊 立即 完结任务 情况
  if (that[taskInfo]['status'] == taskStatus.done) {
    // 再次运行 将 重新开始
    that[taskInfo][currentIndex] = 0;

    // 结束 等待 运行
    that[taskInfo]['status'] = taskStatus.wait;
    return false;
  }
  //   当 task 任务指针 指向 末尾 直接置为 0 并返回
  if (that[taskInfo][currentIndex] >= that[infactTask].length) {
    // 再次运行 将 重新开始
    that[taskInfo][currentIndex] = 0;

    // 结束 等待 运行
    that[taskInfo]['status'] = taskStatus.wait;
    return false;
  }
  return returninf;
}

/**
 * 重置 props 为初始化 如果中间添加 了某个属性 则 直接记录
 */
function rebackProps() {
  this[taskInfo][currentPropsObj] = emptyClone(this['propsVal']);
}

function mindTask() {
  let mindArr = { data: [] };
  let that = this;
  /**
   * 只 运行一次
   */
  if (this['mindTaskCall']) {
    this['mindTaskCall'] = false;
    this['mindTask'] = mindTask.call(this);
    this['mindTask'](...arguments);
    delete this['mindTaskCall'];
  }
  /**
   * 当前 Task 信息集
   */
  let remindTask = 'remindTask';

  /**
   * 回溯 原 Task 信息集
   */
  function rebackTask() {
    this['taskInfo']['status'] = 'done';
    // console.log(that, remindTask);
    this['task'] = this['remindTask'];
    delete this['remindTask'];
  }

  /**
   * 运行 处理好的 函数集
   * @param {Array} minT 组织好的 函数集 包含 回溯功能
   */
  function runT(minT) {
    /**
     * 记录 当前Task信息集
     */
    that[remindTask] = that[infactTask];
    that[infactTask] = minT;

    /**
     * 运行 task
     */
    runTask.call(that);
  }

  /**
   * 定向 返回 拟定  的 task 任务指定集合
   */
  function directTask() {
    let arg = arguments;
    let settleTask = [];
    let emptClone_task;

    if (arg[0] == undefined) {
      arg[0] = 0;
    }
    if (arg[1] == undefined) {
      arg[1] = emptClone_task.length - 1;
    }

    // if (arg.length == 2) {
    //   /**
    //    * from to
    //    */
    //   if (
    //     toStringTypeCheck(arg[0], 'number') &&
    //     toStringTypeCheck(arg[0], 'number')
    //   ) {
    //     settleTask = emptClone_task.splice(...arg);
    //   } else if (
    //     toStringTypeCheck(arg[0], 'number') ^
    //     toStringTypeCheck(arg[1], 'number')
    //   ) {
    //     // trytoGetTaskFuncI(arg,0)
    //     // trytoGetTaskFuncI(arg,1)
    //     //     forgetI(arg)
    //     //     settleTask= emptClone_task.splice(...arg)
    //     // }else{
    //     // trytoGetTaskFuncI(arg,0)
    //     // trytoGetTaskFuncI(arg,1)
    //     forgetI(arg);
    //     settleTask = mapTask(arg);
    //   }
    // }
    // if (arg.length > 2) {
    //   for (let i = 0; i < arg.length; i++) {
    //     settleTask.push(emptClone_task[arg[i]]);
    //   }
    // }
    // if (toStringTypeCheck(arg[0], 'string')) {
    //   for (let i = 0; i < arg.length; i++) {
    //     for (let j = 0; j < emptClone_task.length; j++) {
    //       // 如果是 函数 则 查找名称 成功 break 当前循环
    //       if (toStringTypeCheck(emptClone_task[j], 'function')) {
    //         if (emptClone_task[j].name == arg[i]) {
    //           settleTask.push(emptClone_task[j]);
    //           // 修订元素
    //           emptClone_task.splice(j, 1);

    //           break;
    //         }
    //       } else if (toStringTypeCheck(emptClone_task[j], 'object')) {
    //         if (emptClone_task[j]['value'].name == arg[i]) {
    //           settleTask.push(emptClone_task[j]);
    //           // 修订元素
    //           emptClone_task.splice(j, 1);

    //           break;
    //         } else if (emptClone_task[j]['function'].name == arg[i]) {
    //           settleTask.push(emptClone_task[j]);
    //           // 修订元素
    //           emptClone_task.splice(j, 1);

    //           break;
    //         }
    //       }
    //     }
    //   }
    // }

    function forgetI(arg) {
      for (let i = 0; i < arg.length; i++) {
        trytoGetTaskFuncI(arg, i);
      }
      // return arg
    }

    function trytoGetTaskFuncI(arg, index) {
      // 如果是 number  即 序号 直接返回
      if (toStringTypeCheck(arg[index], 'number')) {
        return;
      } else if (toStringTypeCheck(arg[index], 'function')) {
        // --函数穿透
        return;
      } else if (toStringTypeCheck(arg[index], 'array')) {
        // 填充 区域 信息
        let a = [];
        if (toStringTypeCheck(arg[index][0], 'string')) {
          arg[index][0] = getStrTaskI(arg[index][0]);
        }
        if (toStringTypeCheck(arg[index][1], 'string')) {
          arg[index][1] = getStrTaskI(arg[index][1]);
        }

        let increaseV = arg[index][0] < arg[index][1] ? 1 : -1;

        for (
          let i = arg[index][0];
          i != arg[index][1] + increaseV;
          i += increaseV
        ) {
          a.push(i);
        }
        // 替换当前元素 换成 连续区间
        arg.splice(index, 1, ...a);
      } else if (toStringTypeCheck(arg[index], 'string')) {
        arg.splice(index, 1, getStrTaskI(arg[index]));
      } else {
        // 其他情况 删除 可能会出错 的情况
        arg.splice(index, 1);
      }

      /**
       * 根据 函数名 返回 task 中的位置
       * @param {String} str 函数名
       */
      function getStrTaskI(str) {
        let emptClone_task = that[infactTask];
        for (let j = 0; j < emptClone_task.length; j++) {
          // 如果是 函数 则 查找名称 成功 break 当前循环
          if (toStringTypeCheck(emptClone_task[j], 'function')) {
            if (emptClone_task[j].name == str) {
              return j;
            }
          } else if (toStringTypeCheck(emptClone_task[j], 'object')) {
            if (emptClone_task[j]['value'].name == str) {
              return j;
            } else if (emptClone_task[j]['function'].name == str) {
              return j;
            }
          }
        }
        return -1;
      }
    }

    function mapTask(arr) {
      let reInf = [];
      for (let i = 0; i < arr.length; i++) {
        if (arr[i] == -1) {
          // 抱歉 遇见了 一些 外部函数名 在mindTask上
          console.log('sorry we got some external function names on mindTask');
          continue;
        }
        // 函数穿透
        if (toStringTypeCheck(arr[i], 'function')) {
          reInf.push(arr[i]);
          continue;
        }
        reInf.push(that[infactTask][arr[i]]);
      }
      return reInf;
    }

    forgetI(arg);
    settleTask = mapTask(arg);

    return settleTask;
  }

  function ref() {
    let arg = arguments;
    if (arg.length == 1) {
      // 指定 运行 已 记录的 mindTask 任务集
      if (toStringTypeCheck(arg[0], 'string')) {
        // console.log(that);

        if (mindArr['data'].indexOf(arg[0]) > -1) {
          runT(mindArr[arg[0]]);
        }
      } else if (toStringTypeCheck(arg[0], 'array')) {
        let a;
        //运行 其他函数 ！！ Dangerous 这个 后续可能有 一定危险 因为 能注入
        if (toStringTypeCheck(arg[0][0], 'function')) {
          a = true;
          //   检测 是否 是 函数数组
          for (let i = 0; i < arg[0].length; i++) {
            if (!toStringTypeCheck(arg[0][i], 'function')) {
              a = false;
              break;
            }
          }
          // 函数数组
          if (a) {
            /**
             * push 返回 最初状态
             */
            arg[0].push(rebackTask);
            // that[infactTask] = arg[0];
            // runTask.call(that);
            runT(arg[0]);
          }
          //   else {
          //     console.log(
          //       'over your first Array arguments is not a Functions array',
          //       arg[0]
          //     );
          //   }
        } else if (toStringTypeCheck(arg[0][0], 'number')) {
          a = true;
          // 检测 是否 是 数字数组
          for (let i = 0; i < arg[0].length; i++) {
            if (!toStringTypeCheck(arg[0][i], 'number')) {
              a = false;
              break;
            }
          }
          // 数字数组
          if (a) {
            let setTask = directTask(...arg[0]);
            setTask.push(rebackTask);
            runT(setTask);
          }
          //   else {
          //     console.log(
          //       'over your first Array arguments is not a Number array',
          //       arg[0]
          //     );
          //   }
        }
        // 如果 是杂糅的 临时 自定义 task 数据
        if (!a) {
          let setTask = directTask(...arg[0]);
          setTask.push(rebackTask);
          runT(setTask);
        }
      }
    } else if (arg.length == 2) {
      // 添加 mindTask 并且 末尾绑定 返回 原 Task 信息
      if (toStringTypeCheck(arg[0], 'string')) {
        if (toStringTypeCheck(arg[1], 'array')) {
          /**
           * push 返回 最初状态
           */
          arg[1].push(rebackTask);
          if (!ObjectOnlyPushSet(mindArr, arg[0], arg[1])) {
            mindArr[arg[0]] = arg[1];
          }
          //   that[infactTask] = arg[1];
          //   runTask.call(that);
          runT(arg[1]);
        }
      }
    }
  }
  return ref;
}

/**
 * 填充函数
 * -
 * 根据不同情况 装填 新建函数
 * @param {Object} asyFunc 解析后的 函数 对象
 */
function fillFunc(asyFunc) {
  // const regThisProp=/this\.(?<thisProps>[\w\.]*)/g
  let funcstr = asyFunc.funcBody;

  let key;
  switch (true) {
    case regSwitchFuncReturn_o.reReturn.test(asyFunc.funcReturn):
      key = asyFunc.funcReturn;
      break;
    case regSwitchFuncReturn_o.reArray.test(asyFunc.funcReturn):
      key = asyFunc.funcReturn;
      break;
    case regSwitchFuncReturn_o.reObject.test(asyFunc.funcReturn):
      key = asyFunc.funcReturn;
      break;
    default:
      key = asyFunc.funcReturn.split('.')[1];
      break;
  }
  let func = Function(...asyFunc.funcArg, funcstr);
  return { function: func, key };
}

/**
 * 获取 用户实例 当前 props 的 数据集合 如果没有 就用 undefined 代替
 * @param {array} queArr 函数 的 参数名称
 * @param {this} that this avanda 用户实例
 * @returns
 */
function getqueryArgus(queArr, that) {
  let returninf = [];
  for (let i = 0; i < queArr.length; i++) {
    if (that[infactProps].indexOf(queArr[i]) > -1) {
      returninf.push(that[infactPropsVal][queArr[i]]);
    } else {
      let regfuncNameWith = new RegExp(`${queArr[i]}\\.*`);
      let regWithprop = new RegExp(`.*\\.${queArr[i]}`);
      for (let i = 0; i < that[infactProps].length; i++) {
        if (regfuncNameWith.test(that[infactProps][i])) {
          returninf.push(that[infactPropsVal][that[infactProps][i]]);
          break;
        } else if (regWithprop.test(that[infactProps][i])) {
          returninf.push(that[infactPropsVal][that[infactProps][i]]);
          break;
        }
      }
      returninf.push(undefined);
    }
  }
  return returninf;
}

/**
 * 超前 设置 函数 信息
 * -
 * @param {this} that this avanda 用户实例
 * @param {String} key 函数返回结果 名称
 * @param {any} val 函数返回值
 */
function presetPropInf(that, key, val) {
  //   exposeProps.call(that, key, val);
  that.exposeProps(key, val);
  that[taskInfo][key] = val;
}

/**
 * 根据 after 信息 进行 设置 settimeNth 函数 方式 运行
 * @param {Object} taskFunc task funcs 任务 函数对象集
 * @param {Number} curr_I 当前 运行到的 节点 位置
 * @returns
 */
function paddingsetNth(taskFunc, curr_I) {
  let lastArr = [];
  let last_i = 0;
  for (let i = 0; i < curr_I; i++) {
    if (taskFunc[i][infactRunBranch] != runBranches.delayRun) {
      continue;
    }
    if (taskFunc[i][delayRunInf][delayWay] == delayways.with) {
      lastArr[last_i] = Math.max(
        getNum(lastArr[last_i] || 0),
        getNum(taskFunc[i][delayRunInf][delayTime])
      );
    } else {
      lastArr.push(getNum(taskFunc[i][delayRunInf][delayTime]));
      last_i++;
    }
  }
  lastArr.push(getNum(taskFunc[curr_I][delayRunInf][delayTime]));

  let returninf = funcAsync(taskFunc[curr_I]['function']);
  let prefixSetTime = `settimeNth([${lastArr}],function(${returninf[
    asyncFuncfuncArg
  ].toString()}){`;
  let suffixSetTime = `})`;
  returninf['funcBody'] = prefixSetTime + returninf['funcBody'] + suffixSetTime;
  return returninf;
}

// /**
//  *
//  * @param {String|Object} key 单个 属性名称 或者 暴露参数集合
//  * @param {String|undefined} val value | undefined
//  * @param {Number|undefined} deepth 只搜索深度 一次
//  */
// function exposeProps(key, val, deepth) {
//   if (deepth == 1) {
//     return;
//   }
//   if (toStringTypeCheck(key, 'string')) {
//     ObjectOnlyPushSet(this[infactProps], key);
//     this[infactPropsVal][key] = val;
//   } else if (toStringTypeCheck(key, 'object')) {
//     for (const inkey in key) {
//       if (Object.hasOwnProperty.call(key, inkey)) {
//         deepth == undefined ? (deepth = 0) : deepth++;
//         exposeProps(inkey, key[inkey], deepth);
//       }
//     }
//   }
// }

/**
 * 直接设置 延迟 运行 settiomeout
 * @param {Object} taskFunc_o task function object 任务函数对象
 */
function paddingsetTimeout(taskFunc_o) {
  let returninf = funcAsync(taskFunc_o['function']);
  let prefixSetTime = `setTimeout(\nfunction(${returninf[
    asyncFuncfuncArg
  ].toString()}){`;
  let suffixSetTime = `},${taskFunc_o[delayRunInf][delayTime]})`;
  returninf['funcBody'] = prefixSetTime + returninf['funcBody'] + suffixSetTime;
  return returninf;
}

/**
 * 异步 运行函数 运行好后 设置信息
 * @param {this} that this avanda 用户实例
 * @param {Function} createFunc_o 解析后的 函数 及 函数 返回 名称
 * @param {array} callArgu 运行函数 所需要的 信息 数据 (已经解析 完成)
 * @returns
 */
async function asyncfunc(that, createFunc_o, callArgu, asyncFunc) {
  let re;
  //   当前函数 的 名称
  let currentFuncN;
  //   记录 函数 运行 结果值
  function signReturnVal(key, val) {
    presetPropInf(that, key, val);
    that[runAsync][currentFuncN][asyncDone] = 'done';
  }

  if (asyncFunc == runAsync) {
    await new Promise((resolve) => {
      let a = { resolve, signReturnVal };
      if (that[runAsync] == undefined) {
        that[runAsync] = { data: [] };
      }
      currentFuncN =
        that['task'][that[taskInfo][currentIndex]]['function'].name;
      if (!ObjectOnlyPushSet(that[runAsync], currentFuncN, a)) {
        that[runAsync][currentFuncN] = a;
      }
      createFunc_o.function.call(a, ...callArgu);
    });
  } else {
    re = await createFunc_o.function(...callArgu);
    // 当前 task 任务 执行 序号
    presetPropInf(that, createFunc_o.key, re);

    return re;
  }
}
/**
 * 返回 异步 函数运行时态 及 函数名称
 * @param {this} that this avanda 用户实例
 * @param {String} str 返回 对应 asyncFunc 运行时态 及 函数名称
 */
function getLastAsyncFunc(that, str) {
  let returninf;
  // 从 最后的 记录 开始 检测 未运行 完成的 异步函数
  if (str == lastAsyncFunc) {
    for (let i = that[runAsync][data].length - 1; i >= 0; i--) {
      if (that[runAsync][that[runAsync][data][i]][asyncDone] != asyncDone) {
        returninf = re(that[runAsync][data][i]);
      }
    }
  } else {
    if (that[runAsync][data].indexOf(str) > -1) {
      returninf = re(str);
    }
  }

  // 如果 全 运行 完成 或 未找到 则 填补 第一个 异步运行 时态
  if (returninf == undefined) {
    returninf = re(that[runAsync][data][0]);
  }
  function re(funcName) {
    return { runAsync: that[runAsync][funcName], funcName };
  }
  return returninf;
}

let a = { name: 'task', settleInfo: taskSettleInf, askForSettles: ['prop'] };
export { a as task };
